Thread: Why multiarray pointer is equal to multiarray[0]?

We create a 2D array with classic declaration:int array[3][4]
And we create an array with malloc(): marray[3][4]
In the first case we find that array=array[0]
BUT in the second marray does not equal to marray[0]
The second appears to me logical but the first not!
In the second case we make the marray with this code:

Code:

int rows = 10;    
    int cols = 10;
    int *data;
    int **marray;
    int i,j;

    /* assume malloc always succeeds */
    data = malloc(rows * cols * sizeof(*data));
    marray = malloc(rows * sizeof(*marray));
    for (i = 0; i < rows; ++i)
    {
        marray[i] = &data[i * cols];
    }

Originally Posted by nonlinearly

In the first case we find that array=array[0]

No, array and array[0] are not equal. What you probably observed is that array, when converted to a pointer, is equal to &array[0], but that is because an array is converted to a pointer to its first element. Furthermore, you should observe that the value of &array is equal to the value of &array[0], since an array begins at its first element.

Oh yeah, I forgot to factor in the fact that you're asking about a 2D array. Anyway, it is still true that multi is not equal to multi[0], since their types differ in an incompatible way. After having read my explanation in post #2, why do you think that the value of multi and the value of multi[0], when they are converted to pointers, are the same?

Ok redefines the question...
We know that when we have a 2D array for example array[2][3] then array is a pointer that points to a second pointer a[0] ie array=&array[0]. And this second pointer points to the address of the a[0][0] element ie &array[0][0]. It seems that this is true only when we set the table with dynamic allocated memory. In case we have a not dynamic declared array then the first pointer (array) points to the same address that array[0] points ie &array[0][0]. This is evident in the previous code.

Originally Posted by nonlinearly

We know that when we have a 2D array for example array[2][3] then array is a pointer that points to a second pointer a[0].

No, an array is not a pointer. If we have a 2D array, then when the array is converted to a pointer to its first element, it is converted to a pointer to an array, not a pointer to a pointer.

Originally Posted by nonlinearly

1. Ok if array is not a pointer then what is it?

An array

Originally Posted by nonlinearly

2. when you say "If we have a 2D array" with witch method the array created? With malloc or not?

Without malloc, i.e., just a normal fixed size array. malloc just allocates memory space and returns a pointer through which we can access the memory; how we interpret the memory allocated is up to us. In this sense, we do not actually create objects of any given type with malloc; rather, we allocate space for the object(s), then access the space through a pointer of the appropriate type such that it appears that we have created the object(s), and in effect, we have created them.

Originally Posted by nonlinearly

3. In your code you have declared the array as pointer to pointer!!! Thus it is pointer to pointer.

No, in my code, I declared a pointer to a pointer. It is not an array. However, the idea is to use this pointer to a pointer as if it were an array of arrays, since you desired to use the array index notation.

Originally Posted by nonlinearly

4. and finally if you say that array is not equal to array[0] then why the snippet code from the book refutes you?

The snippet from your book does not demonstrate that array is equal to array[0]. It demonstrates that the value of array is equal to the value of array[0], when array and array[0] are converted to pointers to their respective first elements. Yes, I know this distinction sounds very pedantic, but when we are discussing this topic of arrays versus pointers, it is necessary to be technically correct concerning arrays versus pointers.

Originally Posted by nonlinearly

if we have an array a[2][3] created with the malloc() like the code in the fist message then array does not equal to array[0] (it seems logical)

Yes, it is logical because a pointer and what the pointer points to are two different things that exist in different locations in memory.

Originally Posted by nonlinearly

if we have an array declared as: int array[2][3] then array=array[0]

Compile this program:

Code:

#include <stdio.h>

int main(void)
{
    int array[2][3] = {{0}};
    if (array == array[0]) {
        puts("equal in value");
    }
    return 0;
}

Your compiler should emit a warning. If not, compile with a higher warning level.

Anyway, I have already explained: an array is converted to a pointer to its first element, hence array and array[0] have the same value.

Ok I have understand...
To conclude therefore:
the way we simulate an array with the malloc has nothing to do with how C perceives a real table (least as regards the interpretation of "array" -the first synthetic-).
So we must be careful when we have a reference to "array" (only) somewhere in the code.
We should seek how created. Because:
1. in the malloc() case array is a pointer that points to a pointer that this second pointer points to the first element of a series of items (deliberately did not mention the word array) and WE give the interpretation that it is a table
2. in the case of a normal fixed size TRUE array is a pointer to the array as a whole and because the start position of the array is the &a[0][0] then the value of array=&a[0][0].

(although I did not understand that C considers on the one hand an array as a whole and on the other hand break it in a separate sub-arrays a[0], a[1],...)

Thank you